Questions
4 of 11
1Evaluate this claim: 'Cosine similarity and normalized dot product always produce identical rankings.' What subtlety do candidates often miss here?
2Many candidates assume increasing ef at query time always improves recall with only a linear latency cost. What's misleading about that assumption?
3Why is 'just add more RAM' not always a valid answer to a Qdrant performance question in a system design interview?
4A candidate claims that quantization always speeds up search. Under what conditions might quantization with rescoring actually be slower than searching un-quantized vectors?
5Why can two identical-looking filter queries - one using an indexed field, one using an equivalent but unindexed field - have wildly different performance, even though they return the same results?
6At billion-point scale, how would your indexing and sharding strategy differ from a design that works fine at ten million points?
7How would you architect a system to gracefully degrade - rather than fail outright - when a burst of traffic exceeds provisioned Qdrant capacity?
8What are the limits of a purely payload-filter-based multitenancy model, and at what point would you need to introduce dedicated shards or collections per tenant instead?
9How would you approach re-embedding a multi-billion-point production collection with a new embedding model with zero search downtime?
10When designing a retrieval system that combines dense, sparse, and multivector reranking at extreme scale, what's the single biggest cost driver you'd optimize first, and why?
11If you were asked to design Qdrant's filtered-HNSW search from scratch, what core problem would you need to solve, and what naive approach would you reject first?
04 / 11

A candidate claims that quantization always speeds up search. Under what conditions might quantization with rescoring actually be slower than searching un-quantized vectors?

Heavy oversampling and rescoring can offset the speed gain

Quantization speeds up the traversal by using smaller vectors, which reduces memory bandwidth and cache misses. But when the configuration demands very high recall, the rescoring step can dominate the total cost, and the overall search can be slower than searching un-quantized vectors. The mechanism is that rescoring performs a full-precision distance computation for every candidate in the oversampled set. The oversampled set is limit * oversampling, and for high recall the oversampling factor may be 5, 10, or more. Each rescore is 4x to 32x more expensive than a quantized distance computation, depending on the scheme. So the rescoring cost is (limit * oversampling) * full_precision_cost, which can exceed the savings from the faster traversal. The second condition is the quantization scheme: binary quantization requires more oversampling than scalar, so its rescoring cost is higher. The third condition is the candidate set size: a reranker over a large candidate set, combined with rescoring, multiplies the full-precision work. The fourth condition is the hardware: if the collection is small enough to fit in cache, the un-quantized traversal is already fast, and the quantization overhead (decompression, rescoring) can make it slower. The fifth condition is the metric and the vector dimension: for low dimensions, the quantized distance computation is not much faster than the full-precision one, so the savings are small relative to the rescoring cost.

The mechanism that determines whether quantization is a net win is the ratio of the traversal cost to the rescoring cost. If the traversal dominates (large collection, many candidates, high ef), quantization is a clear win because it speeds up the dominant part. If the rescoring dominates (high oversampling, large candidate set, high recall target), quantization can be a net loss because the rescoring is full-precision and grows with the oversampled set. The break-even point depends on the oversampling factor, the vector dimension, the quantization scheme, and the hardware. In practice, the right approach is to measure the end-to-end latency with and without quantization at the same recall level, not just the traversal latency. The common mistake is to measure the quantized traversal in isolation and conclude that quantization is faster, without accounting for the rescoring. The second mistake is to set a very high oversampling factor by default, which makes the rescoring dominate. The third mistake is to compare the quantized configuration at a higher recall than the unquantized one and attribute the latency difference to quantization when it is actually the recall target. Version note: the quantization search parameters (rescore, oversampling) and the exact behavior of rescoring have changed across Qdrant releases. The default oversampling and whether rescoring is on by default differ. Measure on your version at the recall level you plan to ship.

  1. 1

    Rescoring cost: full-precision distance for every oversampled candidate, 4x-32x the quantized cost.

  2. 2

    High oversampling: needed for high recall with binary quantization, can dominate the total cost.

  3. 3

    Large candidate set: a reranker over many candidates multiplies the full-precision work.

  4. 4

    Small collection: fits in cache, unquantized traversal is fast, quantization overhead can be a net loss.

  5. 5

    Low dimension: quantized distance is not much faster, savings are small.

  6. 6

    Break-even: traversal cost vs rescoring cost; measure end-to-end at the same recall level.

  7. 7

    Configuration: quantize for traversal, but keep the candidate set and oversampling bounded.

  8. 8

    Measurement: compare latency with and without quantization at the same recall, not at the same ef.

The trade-off is between memory savings and the rescoring cost. Quantization always saves memory; it does not always save latency. For a memory-constrained deployment, quantization is worth it even if the latency is the same, because it enables the collection to fit. For a latency-constrained deployment where the collection already fits in RAM, quantization may not be worth it. The common mistakes are: (1) assuming quantization always speeds up search; (2) measuring the traversal in isolation; (3) comparing configurations at different recall levels; (4) setting oversampling too high; (5) not considering the candidate set size for a downstream reranker. Version note: the quantization schemes, the oversampling parameter, and the rescoring behavior have evolved across Qdrant releases. Measure on your version with your data.

javascript

Version-dependent: the quantization search parameters and the rescoring behavior have changed across Qdrant releases. The default oversampling and whether rescoring is on by default differ. Measure on your version at the recall level you plan to ship.

Difficulty: 8/10
Topics: Quantization, Oversampling and Rescoring, Latency Tuning

Scenario Questions

0-2 years experience
  1. 1

    You enable binary quantization and the p99 gets worse. Explain how that is possible.

  2. 2

    A teammate says quantization always speeds up search. Explain the condition under which it does not.

2-5 years experience
  1. 1

    Your quantized collection with oversampling 10 is slower than the unquantized one at the same recall. Describe the diagnosis and the fix.

  2. 2

    You need high recall and low latency on a quantized collection. Describe how you would tune the configuration.

5-8 years experience
  1. 1

    Design a benchmark that compares quantized and unquantized configurations at the same recall level, and identify the conditions under which each wins.

  2. 2

    You have a latency SLO and a memory budget. Describe how you would decide between quantization and a smaller collection.

8+ years experience
  1. 1

    Derive the break-even point where quantization becomes a net latency win, as a function of dimension, oversampling, and hardware.

  2. 2

    You are designing a system that must adaptively choose between quantized and unquantized search based on the query and the load. Describe the architecture.

Follow-up Questions

  • How would you find the oversampling factor that minimizes latency for a given recall target?
  • If quantization is not a latency win for your workload, is it still worth using? Explain the reasoning.